Mouse Hover is a common browser interaction in which the mouse pointer is moved over a particular web element without necessarily clicking it. Many modern websites use hover interactions to display dropdown menus, submenus, tooltips, hidden buttons, product information, navigation options, or additional content.
In Selenium WebDriver, mouse hover is generally performed using the Actions class and its moveToElement() method. The moveToElement() method moves the mouse pointer to the target WebElement and is commonly used for hover-based interactions.
Selenium Training Course | Register for Course Demo
Mouse Hover means moving the mouse pointer over a web element and keeping the pointer on that element. A website can respond to this event by displaying additional information or changing the state of the element.
For example, when the mouse is moved over an e-commerce category such as Electronics, a submenu containing Mobile, Laptop, Television, and Accessories may appear.
Home
Products
|
+-- Electronics
| |
| +-- Mobiles
| +-- Laptops
| +-- Cameras
|
+-- Clothing
+-- Shoes
When the user moves the mouse over Electronics, the submenu may become visible.
The Actions class is Selenium's API for creating complex keyboard and mouse interactions. It supports mouse movement, clicking, double-clicking, drag-and-drop, keyboard actions, and other chained interactions.
import org.openqa.selenium.interactions.Actions;
Actions actions = new Actions(driver);
actions.moveToElement(element).perform();
The moveToElement() method moves the mouse pointer to the target WebElement. By default, Selenium moves the pointer toward the element's in-view center.
actions.moveToElement(element).perform();
The perform() method executes the configured action sequence. Simply creating an action chain does not complete the browser interaction until the action is performed.
Actions actions = new Actions(driver);
actions.moveToElement(menu).perform();
Locate Web Element
↓
Create Actions Object
↓
moveToElement()
↓
perform()
↓
Mouse moves over element
↓
Hover event is triggered
↓
Dropdown / Tooltip / Menu appears
WebElement menu = driver.findElement(By.id("products"));
Actions actions = new Actions(driver);
actions.moveToElement(menu).perform();
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
public class MouseHoverExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
WebElement menu = driver.findElement(By.id("products"));
Actions actions = new Actions(driver);
actions.moveToElement(menu).perform();
driver.quit();
}
}
WebElement menu = driver.findElement(
By.xpath("//span[text()='Products']")
);
Actions actions = new Actions(driver);
actions.moveToElement(menu).perform();
WebElement menu = driver.findElement(
By.cssSelector(".products-menu")
);
new Actions(driver)
.moveToElement(menu)
.perform();
WebElement services = driver.findElement(
By.xpath("//a[text()='Services']")
);
Actions actions = new Actions(driver);
actions.moveToElement(services).perform();
A very common automation scenario is to hover over a parent menu and then click an option that appears underneath it.
WebElement products = driver.findElement(
By.id("products")
);
WebElement laptops = driver.findElement(
By.xpath("//a[text()='Laptops']")
);
Actions actions = new Actions(driver);
actions.moveToElement(products).perform();
laptops.click();
WebElement products = driver.findElement(
By.id("products")
);
WebElement laptops = driver.findElement(
By.xpath("//a[text()='Laptops']")
);
Actions actions = new Actions(driver);
actions
.moveToElement(products)
.click(laptops)
.perform();
Sometimes a submenu needs a short amount of time to become visible. Selenium's Actions API supports pauses within an action chain.
import java.time.Duration;
actions
.moveToElement(products)
.pause(Duration.ofSeconds(1))
.click(laptops)
.perform();
Use explicit waits for element conditions whenever possible rather than relying on arbitrary sleeps.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement menu = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("products")
)
);
new Actions(driver)
.moveToElement(menu)
.perform();
import java.time.Duration;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
WebElement products = driver.findElement(
By.id("products")
);
Actions actions = new Actions(driver);
actions.moveToElement(products).perform();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement submenu = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("product-submenu")
)
);
submenu.click();
E-commerce websites often display buttons such as Quick View, Add to Wishlist, or Add to Cart only when the user hovers over a product card.
WebElement product = driver.findElement(
By.cssSelector(".product-card")
);
Actions actions = new Actions(driver);
actions.moveToElement(product).perform();
WebElement product = driver.findElement(
By.cssSelector(".product-card")
);
Actions actions = new Actions(driver);
actions.moveToElement(product).perform();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement quickView = wait.until(
ExpectedConditions.elementToBeClickable(
By.cssSelector(".quick-view")
)
);
quickView.click();
Tooltips are small information boxes that appear when the user moves the mouse over an icon, button, or other element.
WebElement infoIcon = driver.findElement(
By.id("info-icon")
);
Actions actions = new Actions(driver);
actions.moveToElement(infoIcon).perform();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement tooltip = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".tooltip")
)
);
String tooltipText = tooltip.getText();
System.out.println(tooltipText);
WebElement profile = driver.findElement(
By.id("profile")
);
new Actions(driver)
.moveToElement(profile)
.perform();
Profile Icon
↓
Mouse Hover
↓
User Menu Appears
↓
Profile
Orders
Settings
Logout
↓
Select Required Option
Some websites contain multiple levels of menus. The tester may need to hover over the first menu, then hover over a submenu item, and finally click a third-level option.
WebElement products = driver.findElement(
By.id("products")
);
WebElement electronics = driver.findElement(
By.id("electronics")
);
WebElement mobiles = driver.findElement(
By.id("mobiles")
);
Actions actions = new Actions(driver);
actions
.moveToElement(products)
.pause(Duration.ofMillis(500))
.moveToElement(electronics)
.pause(Duration.ofMillis(500))
.moveToElement(mobiles)
.click()
.perform();
Products
↓
Electronics
↓
Mobiles
↓
Android Phones
↓
Click
Selenium also provides an overloaded moveToElement() method that allows the mouse to move to a position relative to the element's in-view center.
actions
.moveToElement(element, 10, 5)
.perform();
WebElement element = driver.findElement(
By.id("menu")
);
new Actions(driver)
.moveToElement(element, 20, 10)
.perform();
| Feature | moveToElement() | moveByOffset() |
|---|---|---|
| Target | Specific WebElement | Current pointer position |
| Purpose | Hover over element | Move pointer by coordinates |
| Typical Usage | Menus and tooltips | Advanced mouse positioning |
| Syntax | moveToElement(element) | moveByOffset(x,y) |
| Mouse Hover | Click |
|---|---|
| Moves pointer over element | Presses and releases mouse button |
| Usually triggers mouseover/hover behavior | Usually triggers click behavior |
| Used for menus and tooltips | Used for buttons and links |
| Uses moveToElement() | Uses click() |
JavaScript click directly invokes the element's click behavior and does not reproduce the same physical pointer movement as a real hover. Therefore, JavaScript click should not be considered a replacement for Mouse Hover when the application specifically depends on pointer movement.
Modern web applications can respond to events such as mouseover, mouseenter, mousemove, and CSS :hover states.
Mouse Pointer
↓
Move to Element
↓
Browser Pointer Event
↓
JavaScript / CSS Handler
↓
UI Changes
.menu:hover .submenu {
display: block;
}
When Selenium moves the pointer over the menu element, the browser can activate the CSS hover state.
element.addEventListener("mouseover", function() {
console.log("Mouse entered element");
});
WebElement account = driver.findElement(
By.xpath("//span[text()='Account']")
);
new Actions(driver)
.moveToElement(account)
.perform();
WebElement dropdown = driver.findElement(
By.cssSelector(".account-dropdown")
);
if (dropdown.isDisplayed()) {
System.out.println("Dropdown is displayed");
}
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement dropdown = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".account-dropdown")
)
);
System.out.println("Dropdown is visible");
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
public class HoverMenuTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com");
WebElement products = driver.findElement(
By.id("products")
);
Actions actions = new Actions(driver);
actions.moveToElement(products).perform();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement submenu = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("submenu")
)
);
System.out.println(
"Submenu displayed: " + submenu.isDisplayed()
);
} finally {
driver.quit();
}
}
}
In a Page Object Model framework, mouse hover functionality can be placed inside the page class so that test classes remain clean and readable.
public class HomePage {
private WebDriver driver;
private Actions actions;
private By productsMenu =
By.id("products");
public HomePage(WebDriver driver) {
this.driver = driver;
this.actions = new Actions(driver);
}
public void hoverProducts() {
WebElement element =
driver.findElement(productsMenu);
actions.moveToElement(element).perform();
}
}
HomePage homePage = new HomePage(driver);
homePage.hoverProducts();
public static void hover(
WebDriver driver,
WebElement element) {
new Actions(driver)
.moveToElement(element)
.perform();
}
WebElement menu = driver.findElement(
By.id("products")
);
hover(driver, menu);
public static void hover(
WebDriver driver,
By locator) {
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
locator
)
);
new Actions(driver)
.moveToElement(element)
.perform();
}
Hard-coded sleeps pause the test for a fixed amount of time regardless of whether the application is ready. Explicit waits allow Selenium to wait for a specific condition.
| Thread.sleep() | Explicit Wait |
|---|---|
| Fixed delay | Condition-based waiting |
| Can make tests slower | Usually more efficient |
| Does not understand page state | Checks application state |
| Less suitable for dynamic UI | Suitable for dynamic UI |
Open Website
↓
Hover over Electronics
↓
Electronics Menu Opens
↓
Hover over Mobiles
↓
Mobile Submenu Opens
↓
Click Android Phones
↓
Products Page Opens
WebElement electronics = driver.findElement(
By.xpath("//a[text()='Electronics']")
);
WebElement mobiles = driver.findElement(
By.xpath("//a[text()='Mobiles']")
);
WebElement android = driver.findElement(
By.xpath("//a[text()='Android Phones']")
);
Actions actions = new Actions(driver);
actions
.moveToElement(electronics)
.pause(Duration.ofMillis(500))
.moveToElement(mobiles)
.pause(Duration.ofMillis(500))
.click(android)
.perform();
A mega menu contains multiple categories and links that appear when the user hovers over a top-level navigation item.
WebElement category = driver.findElement(
By.cssSelector(".category-menu")
);
new Actions(driver)
.moveToElement(category)
.perform();
WebElement helpIcon = driver.findElement(
By.cssSelector(".help-icon")
);
new Actions(driver)
.moveToElement(helpIcon)
.perform();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement tooltip = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".tooltip")
)
);
String text = tooltip.getText();
System.out.println("Tooltip: " + text);
WebElement avatar = driver.findElement(
By.cssSelector(".user-avatar")
);
new Actions(driver)
.moveToElement(avatar)
.perform();
WebElement button = driver.findElement(
By.id("submit")
);
new Actions(driver)
.moveToElement(button)
.perform();
Sometimes the application changes an element's class, attribute, or visual state after hover. The test can verify a DOM change if the application exposes a testable state.
WebElement button = driver.findElement(
By.id("submit")
);
new Actions(driver)
.moveToElement(button)
.perform();
String className = button.getAttribute("class");
System.out.println(className);
A submenu may exist in the DOM but remain hidden until the mouse pointer reaches its parent element. In such cases, locating the submenu may succeed, but interacting with it before hovering can fail because it is not visible or interactable.
Locate Parent
↓
Hover Parent
↓
Wait for Submenu
↓
Locate/Interact with Submenu
WebElement parent = driver.findElement(
By.id("parent")
);
new Actions(driver)
.moveToElement(parent)
.perform();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement child = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("child")
)
);
child.click();
This exception can occur when Selenium attempts to interact with an element that is not currently in an interactable state.
For hover menus, common causes include:
A dynamic application can replace a DOM element after hovering. The previously stored WebElement reference can then become stale.
A common solution is to locate the element again after the DOM update rather than reusing an old reference.
Selenium can raise a move-target-related exception when a mouse movement target or offset ends up outside the valid viewport or document area. This is especially relevant when using offset-based mouse movement.
| Problem | Possible Solution |
|---|---|
| Wrong locator | Inspect the element and correct the locator |
| Menu not visible | Hover over the parent first |
| Animation still running | Use an appropriate explicit wait |
| Element outside viewport | Bring the element into view or use Selenium's element movement behavior |
| Overlay blocking element | Handle the overlay or wait for it to disappear |
| DOM refreshed | Locate the element again |
If the element is not visible in the current viewport, Selenium's moveToElement() operation can scroll the element into view before performing the mouse movement.
WebElement element = driver.findElement(
By.id("menu")
);
new Actions(driver)
.moveToElement(element)
.perform();
JavaScript can sometimes be useful for inspecting or manipulating page state, but normal Selenium Actions should be preferred when the goal is to reproduce the user's actual mouse interaction.
| Test Step | Expected Result |
|---|---|
| Open application | Application loads successfully |
| Locate menu | Menu is found |
| Move mouse over menu | Hover state is triggered |
| Wait for submenu | Submenu becomes visible |
| Click submenu | Expected page opens |
| Verify page | Correct page is displayed |
Test Case ID: TC_HOVER_001
Test Case: Verify product submenu using mouse hover
Precondition:
User is on the application home page.
Steps:
1. Locate Products menu.
2. Move mouse over Products.
3. Wait for submenu.
4. Verify submenu is displayed.
5. Click required submenu item.
6. Verify destination page.
Expected Result:
The submenu should appear after hovering
and the selected option should open correctly.
Hover actions can be combined with TestNG data-driven testing when several menu options need to be tested.
@DataProvider(name = "menus")
public Object[][] menus() {
return new Object[][] {
{"Electronics"},
{"Clothing"},
{"Shoes"}
};
}
@Test(dataProvider = "menus")
public void verifyMenuHover(String menuName) {
WebElement menu = driver.findElement(
By.xpath("//a[text()='" + menuName + "']")
);
new Actions(driver)
.moveToElement(menu)
.perform();
System.out.println(
"Hovered over: " + menuName
);
}
@FindBy(id = "products")
WebElement productsMenu;
public void hoverProducts() {
new Actions(driver)
.moveToElement(productsMenu)
.perform();
}
Test Class
↓
Page Object
↓
Hover Utility
↓
Actions Class
↓
WebDriver
↓
Browser
↓
Hover Event
public void hoverAndWait(
By locator,
Duration duration) {
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
locator
)
);
new Actions(driver)
.moveToElement(element)
.pause(duration)
.perform();
}
List<WebElement> menus = driver.findElements(
By.cssSelector(".menu-item")
);
Actions actions = new Actions(driver);
for (WebElement menu : menus) {
actions.moveToElement(menu).perform();
}
Taking a screenshot immediately after hover can help diagnose whether the expected menu or tooltip appeared.
WebElement menu = driver.findElement(
By.id("products")
);
new Actions(driver)
.moveToElement(menu)
.perform();
File screenshot =
((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
WebElement menu = driver.findElement(
By.id("products")
);
new Actions(driver)
.moveToElement(menu)
.perform();
WebElement submenu = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.id("submenu")
)
);
Assert.assertTrue(
submenu.isDisplayed(),
"Submenu is not displayed after hover"
);
String expectedTitle = "Mobiles";
WebElement products = driver.findElement(
By.id("products")
);
WebElement mobiles = driver.findElement(
By.id("mobiles")
);
new Actions(driver)
.moveToElement(products)
.pause(Duration.ofMillis(500))
.moveToElement(mobiles)
.click()
.perform();
Assert.assertTrue(
driver.getTitle().contains(expectedTitle)
);
Actions class for real pointer interactions.
click() when only hover is required.Thread.sleep() everywhere.perform().
Actions actions = new Actions(driver);
actions.moveToElement(element).perform();
new Actions(driver)
.moveToElement(parentElement)
.click(childElement)
.perform();
new Actions(driver)
.moveToElement(element)
.pause(Duration.ofSeconds(1))
.perform();
new Actions(driver)
.moveToElement(element, 10, 5)
.perform();
| Action | Actions Method | Typical Use |
|---|---|---|
| Hover | moveToElement() | Menus and tooltips |
| Click | click() | Buttons and links |
| Double Click | doubleClick() | Double-click interactions |
| Right Click | contextClick() | Context menus |
| Drag and Drop | dragAndDrop() | Moving elements |
| Offset Movement | moveByOffset() | Coordinate-based movement |
Mouse Hover is the action of moving the mouse pointer over an element without necessarily clicking it. It is commonly used to trigger menus, tooltips, hidden controls, and other hover-based UI behavior.
In Java Selenium, Mouse Hover is commonly performed using the Actions class and the moveToElement() method.
Actions actions = new Actions(driver);
actions.moveToElement(element).perform();
The Actions class from org.openqa.selenium.interactions is commonly used for mouse hover operations.
perform() executes the configured action sequence. It is used to execute the built action sequence in the browser.
The WebElement interface itself does not provide a dedicated hover method. The common Selenium approach is to use Actions.moveToElement().
First locate the parent element, move the mouse over it using moveToElement(), wait for the submenu to become visible or clickable, and then interact with the submenu.
Technically, a test can pause after hovering, but explicit waits are generally more appropriate because they wait for a meaningful application condition instead of always waiting for a fixed duration.
moveToElement() moves the mouse to a specified WebElement, while moveByOffset() moves the mouse relative to its current pointer position. Both are mouse movement operations provided through Selenium's Actions API.
Yes. Hover actions can be implemented as methods inside Page Object classes. This keeps locators and UI interaction logic separate from test cases.
Create an automation test for an e-commerce website with the following flow:
src
├── test
│ └── HoverMenuTest.java
├── pages
│ └── HomePage.java
└── utils
└── MouseActions.java
public class MouseActions {
private WebDriver driver;
public MouseActions(WebDriver driver) {
this.driver = driver;
}
public void hover(WebElement element) {
new Actions(driver)
.moveToElement(element)
.perform();
}
}
public class HomePage {
private WebDriver driver;
private By products =
By.id("products");
public HomePage(WebDriver driver) {
this.driver = driver;
}
public void hoverProducts() {
WebElement element =
driver.findElement(products);
new Actions(driver)
.moveToElement(element)
.perform();
}
}
@Test
public void verifyProductsHover() {
HomePage homePage =
new HomePage(driver);
homePage.hoverProducts();
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement submenu = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("submenu")
)
);
Assert.assertTrue(
submenu.isDisplayed()
);
}
moveToElement().perform().
| Concept | Key Point |
|---|---|
| Mouse Hover | Moving the pointer over an element |
| Actions | Selenium class for complex user interactions |
| moveToElement() | Moves mouse to an element |
| perform() | Executes the configured action |
| Pause | Allows an action chain to wait between actions |
| Explicit Wait | Waits for a specific application condition |
| Nested Hover | Hover through multiple menu levels |
| Page Object | Keeps hover logic organized in frameworks |
Actions class is commonly used for hover operations.moveToElement().perform().
Learn more about Selenium WebDriver and automation testing:
Mouse Hover is an essential Selenium WebDriver concept for automating modern web applications. Menus, tooltips, product cards, profile menus, mega menus, and hidden controls frequently depend on mouse movement. Selenium's Actions class provides the standard mechanism for performing these pointer interactions, with moveToElement() being the key method for hover operations.
A reliable Mouse Hover automation flow is: locate the element → move the mouse to the element → perform the action → wait for dynamic content when necessary → verify the expected result → interact with the displayed element.
